Not only can this prevent some constraints from being inferred, it can
lead to the wrong constraints being inferred due to partial unification,
see comment.

This change broke one test, in i6565.scala we had:

  type Lifted[A] = Err | A
  extension [O, U](o: Lifted[O]) def map(f: O => U): Lifted[U] = ???

  val error: Err = Err()

  lazy val ok: Lifted[String] = {
    point("a").map(_ => if true then "foo" else error)
      // now fails because error does not have type String
  }

Because `isMatchingApply` can now deal with aliased types, when typing
the lambda we get the constraint `U <: String` from
`Lifted[U] <: Lifted[String]`, so `Err` is no longer a subtype of the
expected result type of the lambda. This can be fixed in a number of
ways: I changed the test to use `flatMap` instead of `map`, but one
could also remove the expected type, or replace it by
`Lifted[Lifted[String]` or `Err | String`.

I think the new behavior is arguably better since using type aliases now
gives you more control on how type inference proceeds, even if it means
that some things that used to typecheck don't anymore.

This change is also necessary to get shapeless to compile after the
following commit which makes partial unification work in more
situation.

So far, like Scala 2, given:

  Either[Int, String] <:< ?F[String]

we were able to infer:

  ?F >: [X] =>> Either[Int, X]

However, in the inverse situation:

  ?F[String] <:< Either[Int, String]

Scala 2, but not Dotty, was able to infer:

  ?F <: [X] =>> Either[Int, X]

This commit fixes this by generalizing the partial unification logic to
be run both in `compareAppliedType2` and `compareAppliedType1`, this
broke a few tests:
- In `anykind.scala`, `kinder1` and `kinder2` became ambiguous, this is
  fixed by moving `kinder2` in a lower priority base trait.
- One of the implicit search in tests/neg/i3452.scala now goes into an
  infinite loop, I've disabled it for now. The issue seems to be related
  to by-name implicits as the divergence checker works when the by-name
  is removed from one of the implicit parameter, I've added the
  non-by-name version in the same file. I've also been able to reproduce the
  same symptoms on master and filed scala#9568.

If `canInstantiate` fails, we fallback to `compareLower` which itself
can fallback to `fourthTry`, so there's no need to fallback to
`fourhTry` inside `canInstantiate` itself.

It turns out that neg/t2712-2.scala actually works in Dotty due to
better type inference.